```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Java多线程编程指南 | 技术小馆</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', 'Noto Serif SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            background-color: #f8fafc;
            color: #1e293b;
            line-height: 1.6;
        }
        .hero {
            background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%);
        }
        .code-block {
            background-color: #1e293b;
            border-left: 4px solid #6366f1;
        }
        .section-card {
            transition: transform 0.3s ease, box-shadow 0.3s ease;
        }
        .section-card:hover {
            transform: translateY(-4px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .concept-icon {
            width: 60px;
            height: 60px;
            background-color: #6366f1;
            color: white;
        }
        .footer {
            background-color: #1e293b;
        }
        .nav-link:hover {
            color: #6366f1;
        }
        .floating-button {
            animation: float 3s ease-in-out infinite;
        }
        @keyframes float {
            0%, 100% { transform: translateY(0); }
            50% { transform: translateY(-10px); }
        }
        .first-letter::first-letter {
            font-size: 3em;
            float: left;
            line-height: 1;
            margin-right: 0.1em;
            color: #6366f1;
        }
    </style>
</head>
<body class="antialiased">
    <!-- 导航栏 -->
    <nav class="bg-white shadow-md sticky top-0 z-50">
        <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
            <div class="flex justify-between h-16">
                <div class="flex items-center">
                    <div class="flex-shrink-0 flex items-center">
                        <i class="fas fa-code text-indigo-600 text-2xl mr-2"></i>
                        <span class="text-xl font-bold text-gray-900">Java多线程编程</span>
                    </div>
                </div>
                <div class="hidden md:ml-6 md:flex md:items-center md:space-x-8">
                    <a href="#basic" class="text-gray-700 hover:text-indigo-600 px-3 py-2 rounded-md text-sm font-medium nav-link">基本概念</a>
                    <a href="#implement" class="text-gray-700 hover:text-indigo-600 px-3 py-2 rounded-md text-sm font-medium nav-link">实现方式</a>
                    <a href="#lifecycle" class="text-gray-700 hover:text-indigo-600 px-3 py-2 rounded-md text-sm font-medium nav-link">生命周期</a>
                    <a href="#sync" class="text-gray-700 hover:text-indigo-600 px-3 py-2 rounded-md text-sm font-medium nav-link">同步互斥</a>
                    <a href="#communication" class="text-gray-700 hover:text-indigo-600 px-3 py-2 rounded-md text-sm font-medium nav-link">线程通信</a>
                    <a href="#safety" class="text-gray-700 hover:text-indigo-600 px-3 py-2 rounded-md text-sm font-medium nav-link">线程安全</a>
                </div>
            </div>
        </div>
    </nav>

    <!-- Hero 区域 -->
    <div class="hero text-white py-20">
        <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-1/2 mb-10 md:mb-0">
                    <h1 class="text-4xl md:text-5xl font-bold leading-tight mb-4">掌握Java多线程编程</h1>
                    <p class="text-xl mb-8 opacity-90">深入理解线程原理，构建高性能并发应用</p>
                    <div class="flex space-x-4">
                        <a href="#basic" class="bg-white text-indigo-600 px-6 py-3 rounded-lg font-medium hover:bg-gray-100 transition duration-300">开始学习</a>
                        <a href="#homework" class="border-2 border-white text-white px-6 py-3 rounded-lg font-medium hover:bg-white hover:text-indigo-600 transition duration-300">查看作业</a>
                    </div>
                </div>
                <div class="md:w-1/2 flex justify-center">
                    <div class="relative w-64 h-64 bg-white bg-opacity-20 rounded-full flex items-center justify-center floating-button">
                        <div class="w-56 h-56 bg-white bg-opacity-30 rounded-full flex items-center justify-center">
                            <i class="fas fa-code-branch text-6xl text-white"></i>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </div>

    <!-- 主要内容区域 -->
    <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
        <!-- 基本概念 -->
        <div id="basic" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="concept-icon rounded-full flex items-center justify-center mr-4">
                    <i class="fas fa-cog text-2xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-900">线程的基本概念</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div class="bg-white p-8 rounded-xl shadow-lg section-card">
                    <p class="text-gray-700 mb-6 first-letter">线程（Thread）是程序执行的最小单位，是程序内部的一条执行路径。每个线程都有自己的执行序列，可以独立运行，但是又共享相同的地址空间和数据。</p>
                    <p class="text-gray-700 mb-6">与进程不同的是，线程之间可以共享内存空间和资源，因此线程的创建和切换开销较小，可以提高程序的执行效率。多线程的优势在于能够同时执行多个任务，充分利用多核处理器的性能，提高程序的并发性和响应速度。</p>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-lg section-card flex items-center">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1711089943382-36c17122-0393-490a-894d-fe2b4243d4ab.png" alt="线程概念图" class="rounded-lg w-full">
                </div>
            </div>
            
            <div class="mt-12">
                <h3 class="text-2xl font-bold text-gray-900 mb-6 flex items-center">
                    <i class="fas fa-random text-indigo-600 mr-2"></i>线程与进程的区别
                </h3>
                <div class="grid md:grid-cols-2 gap-8">
                    <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                        <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1711090038259-776aba2e-6e11-45f9-bbaa-38d3ecc77fb4.png" alt="线程与进程区别" class="rounded-lg w-full mb-4">
                        <ul class="list-disc pl-5 text-gray-700 space-y-2">
                            <li>进程是操作系统分配资源的最小单位，拥有独立的内存空间和数据，而线程是进程的子任务，共享进程的内存空间和资源。</li>
                            <li>进程之间相互独立，通信需要通过进程间通信机制，而线程之间共享内存，可以直接进行数据交换。</li>
                            <li>创建和销毁线程的开销较小，切换线程的速度较快，而创建和销毁进程的开销较大。</li>
                        </ul>
                    </div>
                    <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                        <h4 class="text-xl font-bold text-gray-900 mb-4 flex items-center">
                            <i class="fas fa-desktop text-indigo-600 mr-2"></i>单进程与多进程操作系统
                        </h4>
                        <div class="space-y-4">
                            <div class="p-4 bg-indigo-50 rounded-lg">
                                <p class="text-gray-700">1. 多进程操作系统是指在同一个时段内可以执行多个任务(时间片)</p>
                            </div>
                            <div class="p-4 bg-indigo-50 rounded-lg">
                                <p class="text-gray-700">2. 边听音乐边敲代码，CPU切换非常快</p>
                            </div>
                            <div class="p-4 bg-indigo-50 rounded-lg">
                                <p class="text-gray-700">3. Windows操作系统-多进程操作系统</p>
                            </div>
                            <div class="p-4 bg-indigo-50 rounded-lg">
                                <p class="text-gray-700">4. Dos操作系统-单进程的操作系统</p>
                            </div>
                            <div class="p-4 bg-indigo-50 rounded-lg">
                                <p class="text-gray-700">5. Linux操作系统-多用户多进程的操作系统</p>
                            </div>
                        </div>
                        <div class="mt-4 p-4 bg-yellow-50 rounded-lg border-l-4 border-yellow-400">
                            <p class="text-gray-700 font-medium">思考：现在的多核CPU是否可以让系统在同一个时刻可以执行多个任务吗？</p>
                        </div>
                    </div>
                </div>
            </div>
        </div>

        <!-- 线程实现方式 -->
        <div id="implement" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="concept-icon rounded-full flex items-center justify-center mr-4">
                    <i class="fas fa-laptop-code text-2xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-900">线程实现方式</h2>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-lg mb-8 section-card">
                <p class="text-gray-700 mb-6">在Java中，有几种常见的方式来创建线程：</p>
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1711090207220-a5da7cf6-40c7-4cb2-a6ee-28767cb7ec1f.png" alt="线程实现方式" class="rounded-lg w-full mb-6">
            </div>
            
            <div class="grid md:grid-cols-3 gap-6">
                <div class="bg-white rounded-xl shadow-lg overflow-hidden section-card">
                    <div class="bg-indigo-600 text-white px-6 py-4">
                        <h3 class="font-bold text-lg flex items-center">
                            <i class="fas fa-arrow-up-from-bracket mr-2"></i>继承Thread类
                        </h3>
                    </div>
                    <div class="p-6">
                        <ul class="list-disc pl-5 text-gray-700 space-y-2 mb-4">
                            <li>创建一个类并继承Thread类。</li>
                            <li>重写Thread类的run()方法，定义线程要执行的任务。</li>
                            <li>创建该类的实例，并调用start()方法启动线程。</li>
                        </ul>
                        <div class="code-block p-4 rounded-lg mb-4">
                            <pre class="text-gray-300"><code>class MyThread extends Thread {
    public void run() {
        // 线程执行的任务
    }
}

// 创建线程实例并启动
MyThread thread = new MyThread();
thread.start();</code></pre>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white rounded-xl shadow-lg overflow-hidden section-card">
                    <div class="bg-indigo-600 text-white px-6 py-4">
                        <h3 class="font-bold text-lg flex items-center">
                            <i class="fas fa-project-diagram mr-2"></i>实现Runnable接口
                        </h3>
                    </div>
                    <div class="p-6">
                        <ul class="list-disc pl-5 text-gray-700 space-y-2 mb-4">
                            <li>创建一个类实现Runnable接口。</li>
                            <li>实现接口中的run()方法，定义线程要执行的任务。</li>
                            <li>创建Runnable接口实现类的实例，并将其作为参数传递给Thread类的构造方法。</li>
                            <li>最后调用Thread对象的start()方法启动线程。</li>
                        </ul>
                        <div class="code-block p-4 rounded-lg mb-4">
                            <pre class="text-gray-300"><code>class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的任务
    }
}

// 创建Runnable接口实现类的实例
MyRunnable runnable = new MyRunnable();

// 创建线程实例并启动
Thread thread = new Thread(runnable);
thread.start();</code></pre>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white rounded-xl shadow-lg overflow-hidden section-card">
                    <div class="bg-indigo-600 text-white px-6 py-4">
                        <h3 class="font-bold text-lg flex items-center">
                            <i class="fas fa-exchange-alt mr-2"></i>使用Callable和Future
                        </h3>
                    </div>
                    <div class="p-6">
                        <ul class="list-disc pl-5 text-gray-700 space-y-2 mb-4">
                            <li>创建一个类实现Callable接口。</li>
                            <li>实现接口中的call()方法，定义线程要执行的任务，并返回执行结果。</li>
                            <li>使用ExecutorService的submit()方法提交Callable任务，得到一个Future对象。</li>
                            <li>通过Future对象的get()方法获取任务执行的结果。</li>
                        </ul>
                        <div class="code-block p-4 rounded-lg">
                            <pre class="text-gray-300"><code>import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class MyCallable implements Callable&lt;Integer&gt; {
    public Integer call() {
        // 线程执行的任务，返回结果
        return 1;
    }
}

// 创建Callable接口实现类的实例
MyCallable callable = new MyCallable();

// 创建线程池
ExecutorService executor = Executors.newSingleThreadExecutor();

// 提交Callable任务，并得到Future对象
Future&lt;Integer&gt; future = executor.submit(callable);

// 获取任务执行结果
try {
    Integer result = future.get();
    System.out.println("Result: " + result);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    // 关闭线程池
    executor.shutdown();
}</code></pre>
                        </div>
                    </div>
                </div>
            </div>
        </div>

        <!-- 线程生命周期 -->
        <div id="lifecycle" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="concept-icon rounded-full flex items-center justify-center mr-4">
                    <i class="fas fa-recycle text-2xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-900">线程的生命周期</h2>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-lg mb-8 section-card">
                <p class="text-gray-700 mb-6">线程生命周期是指线程从创建到终止的整个过程，它包括线程的几个状态以及状态之间的转换。了解线程的生命周期对于理解多线程编程是至关重要的。</p>
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1711090355576-2dbe0497-9b24-408f-b7fe-188aef03cf69.png" alt="线程生命周期" class="rounded-lg w-full mb-6">
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <h3 class="text-xl font-bold text-gray-900 mb-4">线程生命周期的状态</h3>
                    <div class="space-y-4">
                        <div class="p-4 bg-indigo-50 rounded-lg">
                            <h4 class="font-bold text-indigo-700 mb-2">1. 新建状态（New）</h4>
                            <p class="text-gray-700">当线程对象被创建后，它就处于新建状态。此时还未调用start()方法启动线程。</p>
                        </div>
                        <div class="p-4 bg-indigo-50 rounded-lg">
                            <h4 class="font-bold text-indigo-700 mb-2">2. 就绪状态（Runnable）</h4>
                            <p class="text-gray-700">当线程对象调用start()方法后，线程进入就绪状态。处于就绪状态的线程已经准备好运行，等待CPU调度执行。</p>
                        </div>
                        <div class="p-4 bg-indigo-50 rounded-lg">
                            <h4 class="font-bold text-indigo-700 mb-2">3. 运行状态（Running）</h4>
                            <p class="text-gray-700">当线程获得CPU执行时间，开始执行run()方法时，线程进入运行状态。处于运行状态的线程正在执行任务，消耗CPU资源。</p>
                        </div>
                        <div class="p-4 bg-indigo-50 rounded-lg">
                            <h4 class="font-bold text-indigo-700 mb-2">4. 阻塞状态（Blocked）</h4>
                            <p class="text-gray-700">在某些情况下，线程由于等待某个条件的满足或者被其他线程阻塞而暂时停止执行，此时线程处于阻塞状态。典型的阻塞场景包括等待I/O完成、等待获取锁等。</p>
                        </div>
                        <div class="p-4 bg-indigo-50 rounded-lg">
                            <h4 class="font-bold text-indigo-700 mb-2">5. 等待/睡眠状态（Waiting/Sleeping）</h4>
                            <p class="text-gray-700">线程执行wait()方法或者sleep()方法时，线程进入等待或睡眠状态。等待状态下的线程需要其他线程的通知才能唤醒，睡眠状态下的线程会在指定时间后自动唤醒。</p>
                        </div>
                        <div class="p-4 bg-indigo-50 rounded-lg">
                            <h4 class="font-bold text-indigo-700 mb-2">6. 终止状态（Terminated）</h4>
                            <p class="text-gray-700">当线程的run()方法执行结束或者调用了stop()方法导致线程被终止时，线程进入终止状态。处于终止状态的线程已经彻底结束了生命周期，不再可用。</p>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <h3 class="text-xl font-bold text-gray-900 mb-4">线程状态的转换</h3>
                    <div class="space-y-3">
                        <div class="flex items-start">
                            <div class="flex-shrink-0 h-10 w-10 rounded-full bg-indigo-100 flex items-center justify-center mr-3">
                                <i class="fas fa-arrow-right text-indigo-600"></i>
                            </div>
                            <div>
                                <p class="text-gray-700"><span class="font-bold">新建状态 -> 就绪状态</span>：调用start()方法启动线程。</p>
                            </div>
                        </div>
                        <div class="flex items-start">
                            <div class="flex-shrink-0 h-10 w-10 rounded-full bg-indigo-100 flex items-center justify-center mr-3">
                                <i class="fas fa-arrow-right text-indigo-600"></i>
                            </div>
                            <div>
                                <p class="text-gray-700"><span class="font-bold">就绪状态 -> 运行状态</span>：线程获得CPU时间片并开始执行任务。</p>
                            </div>
                        </div>
                        <div class="flex items-start">
                            <div class="flex-shrink-0 h-10 w-10 rounded-full bg-indigo-100 flex items-center justify-center mr-3">
                                <i class="fas fa-arrow-right text-indigo-600"></i>
                            </div>
                            <div>
                                <p class="text-gray-700"><span class="font-bold">运行状态 -> 阻塞状态</span>：线程等待某个条件的满足或者被其他线程阻塞。</p>
                            </div>
                        </div>
                        <div class="flex items-start">
                            <div class="flex-shrink-0 h-10 w-10 rounded-full bg-indigo-100 flex items-center justify-center mr-3">
                                <i class="fas fa-arrow-right text-indigo-600"></i>
                            </div>
                            <div>
                                <p class="text-gray-700"><span class="font-bold">运行状态 -> 等待/睡眠状态</span>：线程调用wait()方法等待通知或者sleep()方法休眠一段时间。</p>
                            </div>
                        </div>
                        <div class="flex items-start">
                            <div class="flex-shrink-0 h-10 w-10 rounded-full bg-indigo-100 flex items-center justify-center mr-3">
                                <i class="fas fa-arrow-right text-indigo-600"></i>
                            </div>
                            <div>
                                <p class="text-gray-700"><span class="font-bold">阻塞状态/等待状态 -> 就绪状态</span>：等待条件满足或者被其他线程唤醒后，线程重新进入就绪状态。</p>
                            </div>
                        </div>
                        <div class="flex items-start">
                            <div class="flex-shrink-0 h-10 w-10 rounded-full bg-indigo-100 flex items-center justify-center mr-3">
                                <i class="fas fa-arrow-right text-indigo-600"></i>
                            </div>
                            <div>
                                <p class="text-gray-700"><span class="font-bold">运行状态/就绪状态 -> 终止状态</span>：线程执行完任务或者被主动终止后，进入终止状态。</p>
                            </div>
                        </div>
                    </div>
                    
                    <div class="mt-6 p-4 bg-yellow-50 rounded-lg border-l-4 border-yellow-400">
                        <h4 class="font-bold text-yellow-700 mb-2">状态转换图示</h4>
                        <div class="mermaid">
                            stateDiagram-v2
                                [*] --> New
                                New --> Runnable: start()
                                Runnable --> Running: 获得CPU
                                Running --> Runnable: 时间片用完/主动yield
                                Running --> Blocked: 等待资源/I/O
                                Blocked --> Runnable: 资源可用
                                Running --> Waiting: wait()
                                Waiting --> Runnable: notify()
                                Running --> Terminated: run()结束
                        </div>
                    </div>
                </div>
            </div>
        </div>

        <!-- 同步与互斥 -->
        <div id="sync" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="concept-icon rounded-full flex items-center justify-center mr-4">
                    <i class="fas fa-lock text-2xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-900">线程的同步与互斥</h2>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-lg mb-8 section-card">
                <p class="text-gray-700 mb-6">线程的同步与互斥是多线程编程中常用的两种技术，用于解决多个线程访问共享资源时可能产生的竞争和冲突问题。</p>
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1711091573152-be0cbb8f-fe2e-4cd7-8adf-480d4d45859c.png" alt="线程同步互斥" class="rounded-lg w-full mb-6">
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <h3 class="text-xl font-bold text-gray-900 mb-4 flex items-center">
                        <i class="fas fa-sync-alt text-indigo-600 mr-2"></i>同步（Synchronization）
                    </h3>
                    <p class="text-gray-700 mb-4">同步是指多个线程在访问共享资源时按照一定的顺序依次进行，以避免对共享资源的并发访问造成的数据不一致或错误。</p>
                    
                    <h4 class="font-bold text-gray-800 mb-2">同步方法</h4>
                    <div class="space-y-4">
                        <div class="p-4 bg-gray-50 rounded-lg">
                            <h5 class="font-bold text-indigo-700 mb-2">1. 同步代码块</h5>
                            <p class="text-gray-700 mb-2">使用synchronized关键字对代码块进行同步，通过锁来保证同一时刻只有一个线程可以执行该代码块。</p>
                            <div class="code-block p-4 rounded-lg">
                                <pre class="text-gray-300"><code>synchronized (obj) {
    // 同步代码块
}</code></pre>
                            </div>
                        </div>
                        
                        <div class="p-4 bg-gray-50 rounded-lg">
                            <h5 class="font-bold text-indigo-700 mb-2">2. 同步方法</h5>
                            <p class="text-gray-700 mb-2">使用synchronized关键字修饰方法，整个方法都会被同步，只有一个线程可以访问该方法。</p>
                            <div class="code-block p-4 rounded-lg">
                                <pre class="text-gray-300"><code>public synchronized void method() {
    // 同步方法
}</code></pre>
                            </div>
                        </div>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <h3 class="text-xl font-bold text-gray-900 mb-4 flex items-center">
                        <i class="fas fa-handshake text-indigo-600 mr-2"></i>互斥（Mutex）
                    </h3>
                    <p class="text-gray-700 mb-4">互斥是指多个线程在访问共享资源时，通过锁机制确保同一时刻只有一个线程能够访问该资源，其他线程需要等待。</p>
                    
                    <h4 class="font-bold text-gray-800 mb-2">锁对象</h4>
                    <div class="space-y-4">
                        <div class="p-4 bg-gray-50 rounded-lg">
                            <h5 class="font-bold text-indigo-700 mb-2">1. 对象锁</h5>
                            <p class="text-gray-700 mb-2">对某个对象加锁，同一时刻只能有一个线程获得该对象的锁。</p>
                            <div class="code-block p-4 rounded-lg">
                                <pre class="text-gray-300"><code>synchronized (obj) {
    // 临界区代码
}</code></pre>
                            </div>
                        </div>
                        
                        <div class="p-4 bg-gray-50 rounded-lg">
                            <h5 class="font-bold text-indigo-700 mb-2">2. 类锁</h5>
                            <p class="text-gray-700 mb-2">对类加锁，同一时刻只能有一个线程获得该类的锁。</p>
                            <div class="code-block p-4 rounded-lg">
                                <pre class="text-gray-300"><code>public synchronized static void method() {
    // 静态同步方法
}</code></pre>
                            </div>
                        </div>
                    </div>
                    
                    <div class="mt-4 p-4 bg-indigo-50 rounded-lg">
                        <h4 class="font-bold text-indigo-700 mb-2">同步与互斥的作用</h4>
                        <ul class="list-disc pl-5 text-gray-700 space-y-1">
                            <li><strong>保护共享资源</strong>：通过同步和互斥机制，确保多个线程对共享资源的访问不会导致数据不一致或错误。</li>
                            <li><strong>避免竞争条件</strong>：多个线程同时访问共享资源可能导致竞争条件，同步和互斥可以避免竞争条件的发生，确保程序的正确性和稳定性。</li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>

        <!-- 线程通信 -->
        <div id="communication" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="concept-icon rounded-full flex items-center justify-center mr-4">
                    <i class="fas fa-comments text-2xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-900">线程之间的通讯</h2>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-lg mb-8 section-card">
                <p class="text-gray-700 mb-6">在多线程编程中，线程间的通信是一种重要的机制，用于协调不同线程之间的操作，实现数据共享和任务协作。Java提供了wait()、notify()、notifyAll() 方法来实现线程之间的通信，这些方法基于对象的监视器实现线程的等待和唤醒。</p>
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1711091795267-7ce5e876-f9f3-4662-b3ff-6a35f196f460.png" alt="线程通信" class="rounded-lg w-full mb-6">
            </div>
            
            <div class="grid md:grid-cols-3 gap-6">
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <h3 class="text-xl font-bold text-gray-900 mb-4 flex items-center">
                        <i class="fas fa-pause-circle text-indigo-600 mr-2"></i>wait() 方法
                    </h3>
                    <p class="text-gray-700">wait() 方法使当前线程进入等待状态，并释放对象的锁，直到其他线程调用notify()或notifyAll()方法唤醒该线程，或者等待时间到达。</p>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <h3 class="text-xl font-bold text-gray-900 mb-4 flex items-center">
                        <i class="fas fa-bell text-indigo-600 mr-2"></i>notify() 方法
                    </h3>
                    <p class="text-gray-700">notify() 方法用于唤醒一个正在等待该对象锁的线程，如果有多个线程等待，只会唤醒其中一个线程，具体唤醒哪个线程由系统决定。</p>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <h3 class="text-xl font-bold text-gray-900 mb-4 flex items-center">
                        <i class="fas fa-bell-slash text-indigo-600 mr-2"></i>notifyAll() 方法
                    </h3>
                    <p class="text-gray-700">notifyAll() 方法用于唤醒所有正在等待该对象锁的线程，使它们从等待状态转为就绪状态，争夺对象的锁。</p>
                </div>
            </div>
            
            <div class="mt-8 bg-white p-6 rounded-xl shadow-lg section-card">
                <h3 class="text-xl font-bold text-gray-900 mb-4 flex items-center">
                    <i class="fas fa-code text-indigo-600 mr-2"></i>示例代码
                </h3>
                <div class="code-block p-4 rounded-lg">
                    <pre class="text-gray-300"><code>public class WaitNotifyExample {
    private final Object lock = new Object();
    private boolean flag = false;

    public void waitForFlag() throws InterruptedException {
        synchronized (lock) {
            while (!flag) {
                System.out.println("Thread waiting...");
                lock.wait(); // 等待通知
            }
            System.out.println("Thread notified.");
        }
    }

    public void notifyFlag() {
        synchronized (lock) {
            flag = true;
            System.out.println("Thread notifying...");
            lock.notify(); // 唤醒等待线程
        }
    }

    public static void main(String[] args) {
        WaitNotifyExample example = new WaitNotifyExample();

        Thread t1 = new Thread(() -> {
            try {
                example.waitForFlag();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            example.notifyFlag();
        });

        t1.start(); // 启动等待线程
        t2.start(); // 启动通知线程
    }
}</code></pre>
                </div>
            </div>
        </div>

        <!-- 线程安全 -->
        <div id="safety" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="concept-icon rounded-full flex items-center justify-center mr-4">
                    <i class="fas fa-shield-alt text-2xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-900">线程安全</h2>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-lg mb-8 section-card">
                <p class="text-gray-700 first-letter">在并发编程中，线程安全是一个至关重要的概念。它涉及到多个线程同时访问共享资源时的正确性和一致性，以及如何避免数据竞争、数据不一致等问题。</p>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <h3 class="text-xl font-bold text-gray-900 mb-4 flex items-center">
                        <i class="fas fa-sync text-indigo-600 mr-2"></i>同步机制
                    </h3>
                    <p class="text-gray-700 mb-4">同步机制是保障线程安全的重要手段之一，常见的同步机制包括使用`synchronized`关键字和`ReentrantLock`锁。通过对共享资源的访问进行同步，可以确保在任意时刻只有一个线程访问该资源，从而避免竞态条件和数据不一致。</p>
                    <div class="code-block p-4 rounded-lg">
                        <pre class="text-gray-300"><code>public class Counter {
    private int count;

    public synchronized void increment() {
        count++;
    }
}</code></pre>
                    </div>
                    
                    <h3 class="text-xl font-bold text-gray-900 mt-6 mb-4 flex items-center">
                        <i class="fas fa-database text-indigo-600 mr-2"></i>使用线程安全的数据结构
                    </h3>
                    <p class="text-gray-700 mb-4">Java提供了许多线程安全的数据结构，如`ConcurrentHashMap`、`CopyOnWriteArrayList`等。这些数据结构内部实现了同步机制，可以安全地在多线程环境下使用，无需额外的同步操作。</p>
                    <div class="code-block p-4 rounded-lg">
                        <pre class="text-gray-300"><code>Map&lt;String, String&gt; concurrentMap = new ConcurrentHashMap&lt;&gt;();
List&lt;String&gt; threadSafeList = new CopyOnWriteArrayList&lt;&gt;();</code></pre>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <h3 class="text-xl font-bold text-gray-900 mb-4 flex items-center">
                        <i class="fas fa-lock-open text-indigo-600 mr-2"></i>使用不可变对象
                    </h3>
                    <p class="text-gray-700 mb-4">不可变对象是线程安全的，因为它们的状态不能被修改。通过设计不可变对象来代替可变对象，可以避免在多线程环境中出现数据竞争和不一致性问题。</p>
                    <div class="code-block p-4 rounded-lg">
                        <pre class="text-gray-300"><code>public final class ImmutableObject {
    private final int value;

    public ImmutableObject(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}</code></pre>
                    </div>
                    
                    <h3 class="text-xl font-bold text-gray-900 mt-6 mb-4 flex items-center">
                        <i class="fas fa-atom text-indigo-600 mr-2"></i>注意原子性操作
                    </h3>
                    <p class="text-gray-700 mb-4">在多线程编程中，需要注意原子性操作的问题。简单的操作可能会被拆分成多个步骤，导致线程切换时发生数据不一致的情况。可以使用`Atomic`类来实现原子性操作。</p>
                    <div class="code-block p-4 rounded-lg">
                        <pre class="text-gray-300"><code>AtomicInteger atomicInteger = new AtomicInteger(0);
atomicInteger.incrementAndGet();</code></pre>
                    </div>
                    
                    <div class="mt-6 p-4 bg-indigo-50 rounded-lg">
                        <h4 class="font-bold text-indigo-700 mb-2">避免死锁和饥饿</h4>
                        <p class="text-gray-700">在设计多线程程序时，需要注意避免死锁和饥饿的问题。合理设计锁的获取顺序、避免持有锁的时间过长等方式可以降低死锁和饥饿的发生概率。保障线程安全是多线程编程中至关重要的一环。通过合理设计和选择同步机制、使用线程安全的数据结构、使用不可变对象等手段，可以有效地保障多线程程序的安全性和稳定性。</p>
                    </div>
                </div>
            </div>
            
            <div class="mt-8 bg-white p-6 rounded-xl shadow-lg section-card">
                <h3 class="text-xl font-bold text-gray-900 mb-4 flex items-center">
                    <i class="fas fa-skull-crossbones text-indigo-600 mr-2"></i>线程死锁
                </h3>
                <p class="text-gray-700 mb-6">在并发编程中，线程死锁是一个常见但又十分棘手的问题。它会导致线程相互等待对方持有的资源，从而造成程序无法继续执行下去。</p>
                
                <div class="grid md:grid-cols-2 gap-6">
                    <div>
                        <h4 class="font-bold text-gray-800 mb-2">什么是线程死锁？</h4>
                        <p class="text-gray-700 mb-4">线程死锁指的是两个或多个线程在互相持有对方所需的资源，并且都在等待对方释放资源，从而导致所有线程无法继续执行下去的状态。线程死锁通常发生在多个线程同时竞争多个资源的情况下。</p>
                        
                        <h4 class="font-bold text-gray-800 mb-2">线程死锁的原因</h4>
                        <ul class="list-disc pl-5 text-gray-700 space-y-1">
                            <li><strong>互斥条件</strong>：每个资源只能被一个线程占用</li>
                            <li><strong>请求与保持条件</strong>：线程持有至少一个资源，并且在等待获取其他资源</li>
                            <li><strong>不剥夺条件</strong>：线程已获得的资源在未使用完之前不能被其他线程强制剥夺</li>
                            <li><strong>循环等待条件</strong>：多个线程之间形成一种循环等待资源的关系</li>
                        </ul>
                        
                        <h4 class="font-bold text-gray-800 mt-4 mb-2">线程死锁的解决方法</h4>
                        <ul class="list-disc pl-5 text-gray-700 space-y-1">
                            <li>避免循环等待条件</li>
                            <li>破坏不可抢占条件</li>
                            <li>破坏持有并等待条件</li>
                            <li>超时等待</li>
                        </ul>
                    </div>
                    
                    <div>
                        <div class="mermaid">
                            graph TD
                                A[线程1持有资源A] -->|请求资源B| B[线程2持有资源B]
                                B -->|请求资源A| A
                        </div>
                    </div>
                </div>
            </div>
            
            <div class="mt-8 bg-white p-6 rounded-xl shadow-lg section-card">
                <h3 class="text-xl font-bold text-gray-900 mb-4 flex items-center">
                    <i class="fas fa-tools text-indigo-600 mr-2"></i>线程的常用类和方法
                </h3>
                <div class="grid md:grid-cols-2 gap-6">
                    <div>
                        <div class="p-4 bg-gray-50 rounded-lg mb-4">
                            <h4 class="font-bold text-indigo-700 mb-2">1. `Thread` 类</h4>
                            <p class="text-gray-700">`Thread` 类是Java中表示线程的基本类，通过继承 `Thread` 类可以创建一个新的线程。它提供了一些常用的方法，如 `start()` 方法用于启动线程，`run()` 方法用于定义线程的执行逻辑，`join()` 方法用于等待线程执行结束等。</p>
                        </div>
                        
                        <div class="p-4 bg-gray-50 rounded-lg mb-4">
                            <h4 class="font-bold text-indigo-700 mb-2">2. `Runnable` 接口</h4>
                            <p class="text-gray-700">`Runnable` 接口定义了一个线程任务的执行逻辑，通过实现 `Runnable` 接口可以将任务与线程分离，提高代码的灵活性。`Runnable` 接口中只有一个 `run()` 方法，需要在其中定义线程的具体逻辑。</p>
                        </div>
                        
                        <div class="p-4 bg-gray-50 rounded-lg mb-4">
                            <h4 class="font-bold text-indigo-700 mb-2">3. `Callable` 和 `Future`</h4>
                            <p class="text-gray-700">`Callable` 接口类似于 `Runnable` 接口，但是它可以返回一个结果，并且可以抛出异常。`Future` 接口用于表示一个异步计算的结果，可以用来获取 `Callable` 返回的结果，或者取消任务的执行。</p>
                        </div>
                    </div>
                    
                    <div>
                        <div class="p-4 bg-gray-50 rounded-lg mb-4">
                            <h4 class="font-bold text-indigo-700 mb-2">4. `Executor` 框架</h4>
                            <p class="text-gray-700">`Executor` 框架是Java中用于管理和执行线程的高级工具。它提供了一系列的线程池和任务调度器，可以方便地管理线程的生命周期、调度任务的执行、控制任务的执行顺序等。</p>
                        </div>
                        
                        <div class="p-4 bg-gray-50 rounded-lg mb-4">
                            <h4 class="font-bold text-indigo-700 mb-2">5. `Lock` 和 `Condition`</h4>
                            <p class="text-gray-700">`Lock` 接口和 `Condition` 接口提供了更灵活和可靠的线程同步和通信机制。与传统的 `synchronized` 关键字相比，它们提供了更多的功能，如可重入锁、公平锁、条件等待等。</p>
                        </div>
                        
                        <div class="p-4 bg-gray-50 rounded-lg">
                            <h4 class="font-bold text-indigo-700 mb-2">6. `Semaphore` 和 `CountDownLatch`</h4>
                            <p class="text-gray-700">`Semaphore` 类和 `CountDownLatch` 类是两个常用的同步辅助类，用于控制多个线程的并发访问和执行顺序。`Semaphore` 可以控制同时访问的线程数量，而 `CountDownLatch` 可以等待一组线程执行完毕后再执行。</p>
                        </div>
                    </div>
                </div>
            </div>
        </div>

        <!-- 作业 -->
        <div id="homework" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="concept-icon rounded-full flex items-center justify-center mr-4">
                    <i class="fas fa-tasks text-2xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-900">作业</h2>
            </div>
            
            <div class="grid md:grid-cols-3 gap-6">
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <div class="flex items-center mb-4">
                        <div class="flex-shrink-0 h-10 w-10 rounded-full bg-indigo-100 flex items-center justify-center mr-3">
                            <span class="text-indigo-600 font-bold">1</span>
                        </div>
                        <h3 class="text-xl font-bold text-gray-900">售票系统模拟</h3>
                    </div>
                    <p class="text-gray-700 mb-4">铁道部发布了一个售票任务，要求销售1000张票，要求有10个窗口来进行销售，请编写多线程程序来模拟这个效果</p>
                    <div class="code-block p-4 rounded-lg">
                        <pre class="text-gray-300"><code>1. 窗口001正在销售第1000张票
2. 窗口001正在销售第999张票
3. 窗口002正在销售第998张票
4. 。。。
5. 窗口010正在销售第1张票
6. 票已经销售完毕</code></pre>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <div class="flex items-center mb-4">
                        <div class="flex-shrink-0 h-10 w-10 rounded-full bg-indigo-100 flex items-center justify-center mr-3">
                            <span class="text-indigo-600 font-bold">2</span>
                        </div>
                        <h3 class="text-xl font-bold text-gray-900">并行计算</h3>
                    </div>
                    <p class="text-gray-700">计算任务，一个包含了2千个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。</p>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-lg section-card">
                    <div class="flex items-center mb-4">
                        <div class="flex-shrink-0 h-10 w-10 rounded-full bg-indigo-100 flex items-center justify-center mr-3">
                            <span class="text-indigo-600 font-bold">3</span>
                        </div>
                        <h3 class="text-xl font-bold text-gray-900">多线程断点续传</h3>
                    </div>
                    <p class="text-gray-700 mb-4">采用多线程技术，改造之前的断点续传的案例，实现多线程断点续传，要求线程的数量可由客户端程序来设置。</p>
                    <img src="https://cdn.nlark.com/yuque/0/2023/png/21449790/1692781715703-200dee74-1f14-46ef-82a7-b0ccf4a56bd3.png" alt="断点续传示意图" class="rounded-lg">
                </div>
            </div>
        </div>
    </div>

    <!-- 页脚 -->
    <footer class="footer text-white py-8">
        <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-lg font-bold">技术小馆</h3>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-gray-300 hover:text-white transition duration-300">www.yuque.com/jtostring</a>
                </div>
            </div>
        </div>
    </footer>

    <script>
        // 初始化Mermaid图表
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis'
            }
        });
        
        // 平滑滚动
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                document.querySelector(this.getAttribute('href')).scrollIntoView({
                    behavior: 'smooth'
                });
            });
        });
    </script>
</body>
</html>
```